home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / yase.arc / EDIT3.ASM < prev    next >
Encoding:
Assembly Source File  |  1986-12-13  |  14.6 KB  |  448 lines
  1. ******************************************************************
  2. * COPYRIGHT (C) 1986 by Donald Krantz and James Stanley
  3. * - Note: This is a real, live, actual, registered copyright,
  4. *   and should be treated as such. This source code is from
  5. *   the book "68000 Assembly Language", Krantz and Stanley,
  6. *   Addison-Wesley Publishing Company, Reading, MA, 1986.
  7. * 
  8. *   Permission granted by the authors for non-commercial use
  9. *   in programs released to the public domain, as long as this
  10. *   copyright notice remains attached and visible.
  11. *
  12. *****************************************************************
  13. * Editor Dispatcher
  14.  
  15.     xref    prtscr,stats,_getkey,sync_curs,case,cursor
  16.     xref    _keyhit,group_1,group_2,group_4,refind,errors
  17.     xref    prompt
  18.     xdef    up,down,right,left,down_page,up_page,del_left
  19.     xdef    toggle,eol,sol,dirty
  20.     xdef    edit
  21.  
  22. #edit.h
  23. #cursor.h
  24.  
  25. ****************************************************************
  26. * EDIT - Main editor dispatcher and executive.
  27. edit:
  28.     bsr    _keyhit        * see if we're busy
  29.     tst.w    d0        * d0 is nonzero if we're busy
  30.     bne    sk1exec        * we skip refresh if busy
  31.     bsr    align_scr    * make sure cursor's on screen
  32.     bsr    prtscr        * Print current buffer
  33.     bsr    stats        * Print editing stats
  34.     move.w    ed_err(a5),d0    * Get edit error flag
  35.     ext.l    d0        * make into longword
  36.     lsl.l    #2,d0        * multiply by four
  37.     move.l    #errors,a0    * get error message lookup table
  38.     add.l    d0,a0        * get offset
  39.     move.l    (a0),a0        * get error string address
  40.     bsr    prompt        * output message (or blank old)
  41.     clr.w    ed_err(a5)    * mark "no errors"
  42. sk1exec:
  43.     move.w    scr_row(a5),-(a7) put cursor where it belongs
  44.     move.w    scr_col(a5),-(a7)
  45.     bsr    cursor
  46.     addq.l    #4,a7        * adjust stack
  47.     bsr    sync_curs    * Put cursor where it belongs
  48.     bsr    _getkey        * get input
  49.     ext.w    d0        * make into a word
  50.     move.l    #dispatch,a0    * load up case table
  51.     bsr    case        * perform required operation
  52.  
  53.     bra    edit        * repeat
  54. *****************************************************************
  55. * Top Level Editor Dispatch Table
  56. dispatch:
  57.     dc.w    23        * Number of valid options
  58.     dc.w    tab        * Tab
  59.     dc.l    in_chr
  60.     dc.w    0        * PC cursor key prefix
  61.     dc.l    group_4
  62.     dc.w    c_up        * Cursor up one line
  63.     dc.l    up
  64.     dc.w    c_down        * Cursor down one line
  65.     dc.l    down
  66.     dc.w    c_right        * Cursor one char right
  67.     dc.l    right
  68.     dc.w    c_left        * Cursor one char left
  69.     dc.l    left
  70.     dc.w    c_w_right    * Cursor one word right
  71.     dc.l    w_right
  72.     dc.w    c_w_left    * Cursor one word left
  73.     dc.l    w_left
  74.     dc.w    return        * Return Key
  75.     dc.l    ret
  76.     dc.w    backsp        * Backspace Key
  77.     dc.l    left
  78.     dc.w    left_del    * Left Delete Character
  79.     dc.l    del_left
  80.     dc.w    right_del    * Right Delete Character
  81.     dc.l    del_right
  82.     dc.w    lit_prefix    * Literal Insertion Prefix
  83.     dc.l    prefix
  84.     dc.w    word_del    * Right Delete Word 
  85.     dc.l    del_word
  86.     dc.w    group1        * Group 1 Commands prefix
  87.     dc.l    group_1    
  88.     dc.w    group2        * Group 2 Commands prefix
  89.     dc.l    group_2
  90.     dc.w    group3        * Group 3 Commands prefix
  91.     dc.l    group_3
  92.     dc.w    line_del    * Delete line key
  93.     dc.l    del_line
  94.     dc.w    page_up        * Page Up key
  95.     dc.l    up_page
  96.     dc.w    page_down    * Page Down key
  97.     dc.l    down_page
  98.     dc.w    repeat        * Repeat Find key
  99.     dc.l    refind
  100.     dc.w    insert_key    * Insert Toggle Key
  101.     dc.l    toggle    
  102.     dc.w    ins_line    * Insert Line key
  103.     dc.l    line_ins
  104.     dc.l    ins_chr        * default - insert character
  105. *****************************************************************
  106. * GROUP_3 - group 3 (window) commands
  107. group_3:
  108.     move.l    #-1,d0        * Set "continue" flag
  109.     addq.l    #4,a7        * lift one return address
  110.     rts            * return to caller of "edit"
  111. *****************************************************************
  112. * RIGHT - Moves cursor right. Returns byte moved in D0.
  113. right:
  114.     clr.w    d0        * setup fake return value
  115.     move.l    e_gap(a5),a0    * check if we can move left
  116.     cmp.l    e_buf(a5),a0    * we look at the end of buffer
  117.     bgt    sk0_rt        * jump if we can't move
  118.     move.l    b_gap(a5),a1    * get destination for char
  119.     move.b    (a0),d0        * save the byte to return it
  120.     cmp.b    #10,(a0)    * check for line crossing
  121.     bne    sk1_rt        * skip if not line crossing
  122.     addq.w    #1,log_lin(a5)    * add one to line count
  123. sk1_rt:
  124.     move.b    (a0)+,(a1)+    * move the byte across gap
  125.     addq.l    #1,e_gap(a5)    * move end pointer
  126.     addq.l    #1,b_gap(a5)    * move start pointer
  127. sk0_rt:
  128.     rts
  129. *****************************************************************
  130. * LEFT - moves cursor left. Returns byte moved in D0.
  131. left:
  132.     clr.w    d0        * setup fake return value
  133.     move.l    b_gap(a5),a0    * check if we can move right
  134.     cmp.l    b_buf(a5),a0    * we look at the start of buffer
  135.     ble    sk0_lf        * jump if we can't move
  136.     move.l    e_gap(a5),a1    * get destination for char
  137.     move.b    -(a0),-(a1)    * move the byte across gap
  138.     move.b    (a1),d0        * save the byte to return it
  139.     cmp.b    #10,(a1)    * check for line crossing
  140.     bne    sk1_lf        * jump if not line crossing
  141.     subq.w    #1,log_lin(a5)    * bump down current line counter
  142. sk1_lf:
  143.     subq.l    #1,e_gap(a5)    * move end pointer
  144.     subq.l    #1,b_gap(a5)    * move start pointer
  145. sk0_lf:
  146.     rts
  147. *****************************************************************
  148. * UP - moves cursor up one line 
  149. up:
  150.     bsr    sol        * move to start of this line
  151.     bsr    left        * move back over newline
  152.     bsr    sol        * move to start of this line
  153.     bsr    outline        * put cursor out into line
  154.     rts
  155. *****************************************************************
  156. * DOWN - moves cursor down one line 
  157. down:
  158.     bsr    eol        * move to end of line
  159.     bsr    right        * jump over newline
  160.     bsr    outline        * put cursor out into line
  161.     rts
  162. *****************************************************************
  163. * W_RIGHT - Moves the cursor one word right
  164. w_right:
  165.     bsr    right        * start right
  166.     tst.b    d0        * look for end-of-file
  167.     beq    sk0_wr        * outta here if end of file
  168.     bsr    isdelim     * look for delimiter
  169.     tst.b    d0        * check return value
  170.     beq    w_right        * loop until we find delimiter
  171. lp0_wr:
  172.     bsr    right        * start right
  173.     tst.b    d0        * look for end-of-file
  174.     beq    sk0_wr        * outta here if end of file
  175.     bsr    isdelim     * look for delimiter
  176.     tst.b    d0        * check return value
  177.     bne    lp0_wr        * loop until we finish delimiters
  178.     bsr    left        * back off one
  179. sk0_wr:
  180.     rts
  181. *****************************************************************
  182. * W_LEFT - move the cursor one word to the left
  183. w_left:
  184.     bsr    left        * start left
  185.     tst.b    d0        * look for start-of-file
  186.     beq    sk0_wl        * outta here if start of file
  187.     bsr    isdelim     * look for delimiter
  188.     tst.b    d0        * check return value
  189.     bne    w_left        * loop while no delimiter
  190. lp0_wl:
  191.     bsr    left        * start left
  192.     tst.b    d0        * look for start-of-file
  193.     beq    sk0_wl        * outta here if start of file
  194.     bsr    isdelim     * look for delimiter
  195.     tst.b    d0        * check return value
  196.     beq    lp0_wl        * loop until we hit delimiters
  197.     bsr    right        * back off one
  198. sk0_wl:
  199.     rts
  200. *****************************************************************
  201. * UP_PAGE - moves cursor up one page
  202. up_page:
  203.     move.w    w_rows(a5),d1    * calculate number of lines
  204.     subq.w    #2,d1        * leave two rows for context
  205.     bgt    sk0_up        * check if we still have some
  206.     clr.w    d1        * we need at least one...
  207. sk0_up:
  208.     bsr    sol        * move to start of this line
  209.     bsr    left        * back up over newline
  210.     tst.w    d0        * check for top of file
  211.     beq    sk1_up        * break out if top of file
  212.     dbra    d1,sk0_up    * loop 'lines' times
  213.     bsr    right        * move over current newline
  214. sk1_up:    
  215.     bsr    outline        * move cursor out into line
  216.     rts
  217. *****************************************************************
  218. * DOWN_PAGE - moves cursor down one page
  219. down_page:
  220.     move.w    w_rows(a5),d1    * calculate number of lines
  221.     subq.w    #3,d1        * leave two rows for context
  222.     bgt    sk0_dn        * check if we still have some
  223.     move.w    #0,d1        * we need at least one...
  224. sk0_dn:
  225.     bsr    eol        * move to end of this line
  226.     bsr    right        * skip over newline
  227.     dbra    d1,sk0_dn    * loop 'lines' times
  228.     bsr    sol        * move to start of this line
  229.     bsr    outline        * move cursor out into line
  230.     rts
  231. *****************************************************************
  232. * DEL_RIGHT - delete one character to the right
  233. del_right:
  234.     bsr    right        * try to move right
  235.     tst.b    d0        * is there anything there?
  236.     beq    sk0dr        * jump if not
  237.     subq.l    #1,b_gap(a5)    * delete character
  238.     bsr    dirty        * set modified flags
  239. sk0dr:
  240.     rts
  241. *****************************************************************
  242. * DEL_LEFT - delete one character to the left
  243. del_left:
  244.     bsr    left        * try to move left
  245.     tst.b    d0        * is there anything there?
  246.     beq    sk0dl        * jump if not
  247.     addq.l    #1,e_gap(a5)    * delete character
  248.     bsr    dirty        * set modified flags
  249. sk0dl:
  250.     rts
  251. *****************************************************************
  252. * DEL_LINE - deletes line that cursor is on
  253. del_line:
  254.     bsr    sol        * move to start of this line
  255.     move.l    b_gap(a5),-(a7)    * save gap start address
  256.     bsr    eol        * move to end of this line
  257.     bsr    right        * and one more for newline
  258.     cmp.b    #10,d0        * make sure we got a newline
  259.     bne    sk0ld        * jump if not
  260.     subq.w    #1,log_lin(a5)    * adjust line count
  261. sk0ld:
  262.     move.l    (a7)+,b_gap(a5)    * poof! line's gone.
  263.     bsr    dirty        * set modified flags
  264.     rts
  265. *****************************************************************
  266. del_word:
  267.     move.l    b_gap(a5),-(a7)    * Save gap pointer
  268.     bsr    w_right        * move cursor one word right
  269.     move.l    (a7)+,b_gap(a5)    * restore pointer, word vanishes
  270.     bsr    dirty        * set modified flags
  271.     rts
  272. *****************************************************************
  273. * PREFIX - Allows human to inser next char typed as literal
  274. prefix:
  275.     bsr    _getkey        * take the next keystroke as-is
  276.     bra    in_chr        * insert whatever comes in
  277. *****************************************************************
  278. ret:
  279.     move.b    #10,d0        * load up a newline
  280.     bra    in_chr        * go insert it
  281. *****************************************************************
  282. toggle:
  283.     not.w    insert(a5)    * complement insert toggle
  284.     rts
  285. *****************************************************************
  286. line_ins:
  287.     move.l    e_gap(a5),a0    * get begin gap pointer
  288.     cmp.l    b_gap(a5),a0    * see if there's room
  289.     ble    sk0_lns        * jump if no room
  290.     move.b    #10,-(a0)    * put in newline
  291.     subq.l    #1,e_gap(a5)    * adjust end pointer
  292.     bsr    dirty        * set modified flags
  293.     rts            * exit
  294. sk0_lns:
  295.     move.w    #2,ed_err(a5)    * error 2 - no more room
  296.     rts
  297. *****************************************************************
  298. ins_chr:
  299.     cmp.b    #$20,d0        * check if char out of range
  300.     blt    sk1_ins        * if out, goto error
  301. in_chr:
  302.     tst.w    insert(a5)    * is insert toggle on?
  303.     bne    sk2_ins        * jump if yes
  304.     move.l    e_gap(a5),a0    * get end-of-gap address
  305.     cmp.l    e_buf(a5),a0    * check if at end of buffer
  306.     bgt    sk2_ins        * yes, go insert
  307.     cmp.b    #10,(a0)    * see if next char is newline
  308.     beq    sk2_ins        * yes, go insert
  309.     move.l    b_gap(a5),a0    * we need to replace...
  310.     move.b    d0,(a0)        * emplace new character
  311.     addq.l    #1,b_gap(a5)    * move begin gap pointer
  312.     addq.l    #1,e_gap(a5)    * move end gap pointer
  313.     bra    sk4_ins        * exit
  314. sk2_ins:
  315.     move.l    b_gap(a5),a0    * get begin gap pointer
  316.     cmp.l    e_gap(a5),a0    * look see if there's room
  317.     bge    sk3_ins        * jump if no room
  318.     move.b    d0,(a0)        * insert character
  319.     addq.l    #1,b_gap(a5)    * move gap pointer
  320.     cmp.b    #10,d0        * check for newline
  321.     bne    sk4_ins        * skip if not
  322.     addq.w    #1,log_lin(a5)    * increment logical line count
  323. sk4_ins:
  324.     bsr    dirty        * set modified flags
  325.     rts            * That's it.
  326. sk1_ins:
  327.     move.w    #1,ed_err(a5)    * error #1 - char out of range
  328.     rts
  329. sk3_ins:
  330.     move.w    #2,ed_err(a5)    * error #2 - no room
  331.     rts
  332. *****************************************************************
  333. * ISDELIM - returns TRUE if char in D0 matches delimiter list
  334. isdelim:
  335.     move.l    #delim,a0    * get delimiter list address
  336.     move.w    #d_cnt,d1    * get delimiter count
  337. lp0_dm:
  338.     cmp.b    (a0)+,d0    * look for a match
  339.     beq    d_true        * found one, jump out
  340.     dbra    d1,lp0_dm    * check all cases
  341.     clr.w    d0        * return FALSE
  342.     rts
  343. d_true:
  344.     move.w    #$FFFF,d0    * return TRUE
  345.     rts
  346.  
  347. delim:    dc.b    9,10,' ,.-+/><()'
  348. d_cnt    equ    *-delim
  349.     dc.w    0
  350. *****************************************************************
  351. * SOL - moves cursor to start of line
  352. sol:
  353.     bsr    left        * try one char back
  354.     tst.b    d0        * check if at top of file
  355.     beq    sk0sol        * jump out if at top of file
  356.     cmp.b    #10,d0        * is this a newline?
  357.     bne    sol        * back up to start of this line
  358.     bsr    right        * re-adjust cursor
  359. sk0sol:
  360.     rts
  361. *****************************************************************
  362. * EOL - moves cursor to end of line
  363. eol:
  364.     bsr    right        * try one char forward
  365.     tst.b    d0        * check if at end of file
  366.     beq    sk0eol        * jump out if at end of file
  367.     cmp.b    #10,d0        * check for newline
  368.     bne    eol        * loop if not newline
  369.     bsr    left        * put cursor behind newline
  370. sk0eol:
  371.     rts    
  372. *****************************************************************
  373. * OUTLINE - moves cursor to current logical column
  374. outline:
  375.     clr.w    d2        * d2 is column accumulator
  376. lp0_ol:
  377.     bsr    right        * try to move right
  378.     tst.b    d0        * check if end-of file
  379.     beq    sk1_ol        * exit if end-of-file
  380.     cmp.b    #10,d0        * check for end of line
  381.     beq    sk0_ol        * done if end-of-line
  382.     addq.w    #1,d2        * start with one column
  383.     cmp.b    #$20,d0        * see if control char
  384.     bge    sk2_ol        * if not, we're done with char
  385.     cmp.b    #tab,d0        * is char a tab?
  386.     beq    sk3_ol        * jump if tab
  387.     subq.l    #1,d2        * take away column for ctrl char
  388.     bra    sk2_ol        * make loop test
  389. sk3_ol:
  390.     move.w    d2,d0        * make a copy of column count
  391.     and.w    #$0007,d0    * check for correct tab column
  392.     beq    sk2_ol        * if so, make loop test
  393.     addq.w    #1,d2        * otherwise, add one space to col
  394.     bra    sk3_ol        * and keep expanding tab
  395. sk2_ol:
  396.     cmp.w    log_col(a5),d2    * are we far enough out?
  397.     ble    lp0_ol        * no, keep trying
  398. sk0_ol:
  399.     bsr    left        * back up to correct position
  400. sk1_ol:
  401.     rts 
  402. *****************************************************************
  403. * ALIGN_SCR - Handles vertical cursor alignment. Puts the cursor
  404. * on the screen if it's off.
  405. align_scr:
  406.     move.l    b_gap(a5),a0    * Get start of gap (cursor loc.)
  407.     cmp.l    top_lef(a5),a0    * see if cursor's off top
  408.     bge    sk0_as        * jump if not off the top
  409. lp0_as:
  410.     subq.l    #1,a0        * start backing off
  411.     cmp.l    b_buf(a5),a0    * don't go under start of file
  412.     beq    sk1_as        * jump if at start of file
  413.     cmp.b    #10,(a0)    * look for newline
  414.     bne    lp0_as        * not newline, try again
  415.     addq.l    #1,a0        * ok, move past newline
  416. sk1_as:
  417.     cmp.l    b_buf(a5),a0    * one last check for nasties
  418.     bge    sk5_as        * no nasties
  419.     move.l    b_buf(a5),a0    * start at top
  420. sk5_as:
  421.     move.l    a0,top_lef(a5)    * reset top of screen
  422.     bra    sk3_as        * exit
  423. sk0_as:
  424.     sub.l    top_lef(a5),a0    * A0 is now chars-to-cursor
  425.     move.l    a0,d0        * we need count in data register
  426.     move.l    top_lef(a5),a0    * A0 is where we start looking
  427.     clr.w    d1        * d1 will be newline count
  428.     bra    sk2_as        * do loop test before check
  429. lp1_as:
  430.     cmp.b    #10,(a0)+    * look for newlines
  431.     bne    sk2_as        * if not newline, don't care
  432.     addq.w    #1,d1        * if newline, increment count
  433. sk2_as:
  434.     dbra    d0,lp1_as    * loop test
  435.     sub.w    w_rows(a5),d1    * see if more newlines than rows
  436.     blt    sk3_as        * if not, we're ok
  437.     move.l    top_lef(a5),a0    * get starting point
  438. lp3_as:
  439.     cmp.b    #10,(a0)+    * we need to skip newlines
  440.     bne    lp3_as        * if not newline, we don't care
  441. sk4_as:
  442.     dbra    d1,lp3_as    * loop for (d1+1) newlines
  443.     move.l    a0,top_lef(a5)    * save new top left corner
  444. sk3_as:
  445.     rts
  446.  
  447.     end
  448.